home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / show / mpeg2decodeWOS.lha / mpeg2decode / src / recon.c < prev    next >
C/C++ Source or Header  |  1999-02-23  |  16KB  |  480 lines
  1. /* Predict.c, motion compensation routines                                    */
  2.  
  3. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  4.  
  5. /*
  6.  * Disclaimer of Warranty
  7.  *
  8.  * These software programs are available to the user without any license fee or
  9.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10.  * any and all warranties, whether express, implied, or statuary, including any
  11.  * implied warranties or merchantability or of fitness for a particular
  12.  * purpose.  In no event shall the copyright-holder be liable for any
  13.  * incidental, punitive, or consequential damages of any kind whatsoever
  14.  * arising from the use of these programs.
  15.  *
  16.  * This disclaimer of warranty extends to the user of these programs and user's
  17.  * customers, employees, agents, transferees, successors, and assigns.
  18.  *
  19.  * The MPEG Software Simulation Group does not represent or warrant that the
  20.  * programs furnished hereunder are free of infringement of any third-party
  21.  * patents.
  22.  *
  23.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24.  * are subject to royalty fees to patent holders.  Many of these patents are
  25.  * general enough such that they are unavoidable regardless of implementation
  26.  * design.
  27.  *
  28.  */
  29.  
  30. #include <stdio.h>
  31.  
  32. #include "config.h"
  33. #include "global.h"
  34.  
  35. /* private prototypes */
  36. static void form_prediction _ANSI_ARGS_((unsigned char *src[], int sfield,
  37.   unsigned char *dst[], int dfield,
  38.   int lx, int lx2, int w, int h, int x, int y, int dx, int dy,
  39.   int average_flag));
  40.  
  41. static void form_component_prediction _ANSI_ARGS_((unsigned char *src, unsigned char *dst,
  42.   int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag));
  43.  
  44. #ifdef STORM
  45. void form_predictions(int bx,int by,int macroblock_type,int motion_type,int PMV[2][2][2],int motion_vertical_field_select[2][2],int dmvector[2],int stwtype)
  46. #else
  47. void form_predictions(bx,by,macroblock_type,motion_type,PMV,motion_vertical_field_select,dmvector,stwtype)
  48. int bx, by;
  49. int macroblock_type;
  50. int motion_type;
  51. int PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
  52. int stwtype;
  53. #endif
  54. {
  55.   int currentfield;
  56.   unsigned char **predframe;
  57.   int DMV[2][2];
  58.   int stwtop, stwbot;
  59.  
  60.   stwtop = stwtype%3; /* 0:temporal, 1:(spat+temp)/2, 2:spatial */
  61.   stwbot = stwtype/3;
  62.  
  63.   if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) 
  64.    || (picture_coding_type==P_TYPE))
  65.   {
  66.     if (picture_structure==FRAME_PICTURE)
  67.     {
  68.       if ((motion_type==MC_FRAME) 
  69.         || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  70.       {
  71.         /* frame-based prediction (broken into top and bottom halves
  72.              for spatial scalability prediction purposes) */
  73.         if (stwtop<2)
  74.           form_prediction(forward_reference_frame,0,current_frame,0,
  75.             Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
  76.             PMV[0][0][0],PMV[0][0][1],stwtop);
  77.  
  78.         if (stwbot<2)
  79.           form_prediction(forward_reference_frame,1,current_frame,1,
  80.             Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
  81.             PMV[0][0][0],PMV[0][0][1],stwbot);
  82.       }
  83.       else if (motion_type==MC_FIELD) /* field-based prediction */
  84.       {
  85.         /* top field prediction */
  86.         if (stwtop<2)
  87.           form_prediction(forward_reference_frame,motion_vertical_field_select[0][0],
  88.             current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  89.             bx,by>>1,PMV[0][0][0],PMV[0][0][1]>>1,stwtop);
  90.  
  91.         /* bottom field prediction */
  92.         if (stwbot<2)
  93.           form_prediction(forward_reference_frame,motion_vertical_field_select[1][0],
  94.             current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  95.             bx,by>>1,PMV[1][0][0],PMV[1][0][1]>>1,stwbot);
  96.       }
  97.       else if (motion_type==MC_DMV) /* dual prime prediction */
  98.       {
  99.         /* calculate derived motion vectors */
  100.         Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]>>1);
  101.  
  102.         if (stwtop<2)
  103.         {
  104.           /* predict top field from top field */
  105.           form_prediction(forward_reference_frame,0,current_frame,0,
  106.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
  107.             PMV[0][0][0],PMV[0][0][1]>>1,0);
  108.  
  109.           /* predict and add to top field from bottom field */
  110.           form_prediction(forward_reference_frame,1,current_frame,0,
  111.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
  112.             DMV[0][0],DMV[0][1],1);
  113.         }
  114.  
  115.         if (stwbot<2)
  116.         {
  117.           /* predict bottom field from bottom field */
  118.           form_prediction(forward_reference_frame,1,current_frame,1,
  119.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
  120.             PMV[0][0][0],PMV[0][0][1]>>1,0);
  121.  
  122.           /* predict and add to bottom field from top field */
  123.           form_prediction(forward_reference_frame,0,current_frame,1,
  124.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
  125.             DMV[1][0],DMV[1][1],1);
  126.         }
  127.       }
  128.       else
  129.         /* invalid motion_type */
  130.         printf("invalid motion_type\n");
  131.     }
  132.     else /* TOP_FIELD or BOTTOM_FIELD */
  133.     {
  134.       /* field picture */
  135.       currentfield = (picture_structure==BOTTOM_FIELD);
  136.  
  137.       /* determine which frame to use for prediction */
  138.       if ((picture_coding_type==P_TYPE) && Second_Field
  139.          && (currentfield!=motion_vertical_field_select[0][0]))
  140.         predframe = backward_reference_frame; /* same frame */
  141.       else
  142.         predframe = forward_reference_frame; /* previous frame */
  143.  
  144.       if ((motion_type==MC_FIELD)
  145.         || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  146.       {
  147.         /* field-based prediction */
  148.         if (stwtop<2)
  149.           form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
  150.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
  151.             PMV[0][0][0],PMV[0][0][1],stwtop);
  152.       }
  153.       else if (motion_type==MC_16X8)
  154.       {
  155.         if (stwtop<2)
  156.         {
  157.           form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
  158.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by,
  159.             PMV[0][0][0],PMV[0][0][1],stwtop);
  160.  
  161.           /* determine which frame to use for lower half prediction */
  162.           if ((picture_coding_type==P_TYPE) && Second_Field
  163.              && (currentfield!=motion_vertical_field_select[1][0]))
  164.             predframe = backward_reference_frame; /* same frame */
  165.           else
  166.             predframe = forward_reference_frame; /* previous frame */
  167.  
  168.           form_prediction(predframe,motion_vertical_field_select[1][0],current_frame,0,
  169.             Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by+8,
  170.             PMV[1][0][0],PMV[1][0][1],stwtop);
  171.         }
  172.       }
  173.       else if (motion_type==MC_DMV) /* dual prime prediction */
  174.       {
  175.         if (Second_Field)
  176.           predframe = backward_reference_frame; /* same frame */
  177.         else
  178.           predframe = forward_reference_frame; /* previous frame */
  179.  
  180.         /* calculate derived motion vectors */
  181.         Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]);
  182.  
  183.         /* predict from field of same parity */
  184.         form_prediction(forward_reference_frame,currentfield,current_frame,0,
  185.           Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
  186.           PMV[0][0][0],PMV[0][0][1],0);
  187.  
  188.         /* predict from field of opposite parity */
  189.         form_prediction(predframe,!currentfield,current_frame,0,
  190.           Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
  191.           DMV[0][0],DMV[0][1],1);
  192.       }
  193.       else
  194.         /* invalid motion_type */
  195.         printf("invalid motion_type\n");
  196.     }
  197.     stwtop = stwbot = 1;
  198.   }
  199.  
  200.   if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  201.   {
  202.     if (picture_structure==FRAME_PICTURE)
  203.     {
  204.       if (motion_type==MC_FRAME)
  205.       {
  206.         /* frame-based prediction */
  207.         if (stwtop<2)
  208.           form_prediction(backward_reference_frame,0,current_frame,0,
  209.             Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
  210.             PMV[0][1][0],PMV[0][1][1],stwtop);
  211.  
  212.         if (stwbot<2)
  213.           form_prediction(backward_reference_frame,1,current_frame,1,
  214.             Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
  215.             PMV[0][1][0],PMV[0][1][1],stwbot);
  216.       }
  217.       else /* field-based prediction */
  218.       {
  219.         /* top field prediction */
  220.         if (stwtop<2)
  221.           form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
  222.             current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  223.             bx,by>>1,PMV[0][1][0],PMV[0][1][1]>>1,stwtop);
  224.  
  225.         /* bottom field prediction */
  226.         if (stwbot<2)
  227.           form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
  228.             current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  229.             bx,by>>1,PMV[1][1][0],PMV[1][1][1]>>1,stwbot);
  230.       }
  231.     }
  232.     else /* TOP_FIELD or BOTTOM_FIELD */
  233.     {
  234.       /* field picture */
  235.       if (motion_type==MC_FIELD)
  236.       {
  237.         /* field-based prediction */
  238.         form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
  239.           current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,
  240.           bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
  241.       }
  242.       else if (motion_type==MC_16X8)
  243.       {
  244.         form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
  245.           current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  246.           bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
  247.  
  248.         form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
  249.           current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
  250.           bx,by+8,PMV[1][1][0],PMV[1][1][1],stwtop);
  251.       }
  252.       else
  253.         /* invalid motion_type */
  254.         printf("invalid motion_type\n");
  255.     }
  256.   }
  257. }
  258.  
  259. #ifdef STORM
  260. static void form_prediction(unsigned char *src[],int sfield,unsigned char *dst[],int dfield,int lx,int lx2,int w,int h,int x,int y,int dx,int dy,int average_flag)
  261. #else
  262. static void form_prediction(src,sfield,dst,dfield,lx,lx2,w,h,x,y,dx,dy,average_flag)
  263. unsigned char *src[]; /* prediction source buffer */
  264. int sfield;           /* prediction source field number (0 or 1) */
  265. unsigned char *dst[]; /* prediction destination buffer */
  266. int dfield;           /* prediction destination field number (0 or 1)*/
  267. int lx,lx2;           /* line strides */
  268. int w,h;              /* prediction block/sub-block width, height */
  269. int x,y;              /* pixel co-ordinates of top-left sample in current MB */
  270. int dx,dy;            /* horizontal, vertical prediction address */
  271. int average_flag;     /* add prediction error to prediction ? */
  272. #endif
  273. {
  274.   /* Y */
  275.   form_component_prediction(src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0),
  276.     lx,lx2,w,h,x,y,dx,dy,average_flag);
  277.  
  278.   if (chroma_format!=CHROMA444)
  279.   {
  280.     lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
  281.   }
  282.  
  283.   if (chroma_format==CHROMA420)
  284.   {
  285.     h>>=1; y>>=1; dy/=2;
  286.   }
  287.  
  288.   /* Cb */
  289.   form_component_prediction(src[1]+(sfield?lx2>>1:0),dst[1]+(dfield?lx2>>1:0),
  290.     lx,lx2,w,h,x,y,dx,dy,average_flag);
  291.  
  292.   /* Cr */
  293.   form_component_prediction(src[2]+(sfield?lx2>>1:0),dst[2]+(dfield?lx2>>1:0),
  294.     lx,lx2,w,h,x,y,dx,dy,average_flag);
  295. }
  296.  
  297. /* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
  298. /* NOTE: the arithmetic below produces numerically equivalent results
  299.  *  to 7.6.4, yet is more elegant. It differs in the following ways:
  300.  *
  301.  *   1. the vectors (dx, dy) are based on cartesian frame 
  302.  *      coordiantes along a half-pel grid (always positive numbers)
  303.  *      In contrast, vector[r][s][t] are differential (with positive and 
  304.  *      negative values). As a result, deriving the integer vectors 
  305.  *      (int_vec[t]) from dx, dy is accomplished by a simple right shift.
  306.  *
  307.  *   2. Half pel flags (xh, yh) are equivalent to the LSB (Least
  308.  *      Significant Bit) of the half-pel coordinates (dx,dy).
  309.  * 
  310.  *
  311.  *  NOTE: the work of combining predictions (ISO/IEC 13818-2 section 7.6.7)
  312.  *  is distributed among several other stages.  This is accomplished by 
  313.  *  folding line offsets into the source and destination (src,dst)
  314.  *  addresses (note the call arguments to form_prediction() in Predict()),
  315.  *  line stride variables lx and lx2, the block dimension variables (w,h), 
  316.  *  average_flag, and by the very order in which Predict() is called.  
  317.  *  This implementation design (implicitly different than the spec) 
  318.  *  was chosen for its elegance.
  319. */
  320.  
  321. #ifdef STORM
  322. static void form_component_prediction(unsigned char *src,unsigned char *dst,int lx,int lx2,int w,int h,int x,int y,int dx,int dy,int average_flag)
  323. #else
  324. static void form_component_prediction(src,dst,lx,lx2,w,h,x,y,dx,dy,average_flag)
  325. unsigned char *src;
  326. unsigned char *dst;
  327. int lx;          /* raster line increment */ 
  328. int lx2;
  329. int w,h;
  330. int x,y;
  331. int dx,dy;
  332. int average_flag;      /* flag that signals bi-directional or Dual-Prime 
  333.                           averaging (7.6.7.1 and 7.6.7.4). if average_flag==1,
  334.                           a previously formed prediction has been stored in 
  335.                           pel_pred[] */
  336. #endif
  337. {
  338.   int xint;      /* horizontal integer sample vector: analogous to int_vec[0] */
  339.   int yint;      /* vertical integer sample vectors: analogous to int_vec[1] */
  340.   int xh;        /* horizontal half sample flag: analogous to half_flag[0]  */
  341.   int yh;        /* vertical half sample flag: analogous to half_flag[1]  */
  342.   int i, j, v;
  343.   unsigned char *s;    /* source pointer: analogous to pel_ref[][]   */
  344.   unsigned char *d;    /* destination pointer:  analogous to pel_pred[][]  */
  345.  
  346.   /* half pel scaling for integer vectors */
  347.   xint = dx>>1;
  348.   yint = dy>>1;
  349.  
  350.   /* derive half pel flags */
  351.   xh = dx & 1;
  352.   yh = dy & 1;
  353.  
  354.   /* compute the linear address of pel_ref[][] and pel_pred[][] 
  355.      based on cartesian/raster cordinates provided */
  356.   s = src + lx*(y+yint) + x + xint;
  357.   d = dst + lx*y + x;
  358.  
  359.   if (!xh && !yh) /* no horizontal nor vertical half-pel */
  360.   {
  361.     if (average_flag)
  362.     {
  363.       for (j=0; j<h; j++)
  364.       {
  365.         for (i=0; i<w; i++)
  366.         {
  367.           v = d[i]+s[i];
  368.           d[i] = (v+(v>=0?1:0))>>1;
  369.         }
  370.       
  371.         s+= lx2;
  372.         d+= lx2;
  373.       }
  374.     }
  375.     else
  376.     {
  377.       for (j=0; j<h; j++)
  378.       {
  379.         for (i=0; i<w; i++)
  380.         {
  381.           d[i] = s[i];
  382.         }
  383.         
  384.         s+= lx2;
  385.         d+= lx2;
  386.       }
  387.     }
  388.   }
  389.   else if (!xh && yh) /* no horizontal but vertical half-pel */
  390.   {
  391.     if (average_flag)
  392.     {
  393.       for (j=0; j<h; j++)
  394.       {
  395.         for (i=0; i<w; i++)
  396.         {
  397.           v = d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1);
  398.           d[i]=(v+(v>=0?1:0))>>1;
  399.         }
  400.      
  401.         s+= lx2;
  402.         d+= lx2;
  403.       }
  404.     }
  405.     else
  406.     {
  407.       for (j=0; j<h; j++)
  408.       {
  409.         for (i=0; i<w; i++)
  410.         {
  411.           d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;
  412.         }
  413.  
  414.         s+= lx2;
  415.         d+= lx2;
  416.       }
  417.     }
  418.   }
  419.   else if (xh && !yh) /* horizontal but no vertical half-pel */
  420.   {
  421.     if (average_flag)
  422.     {
  423.       for (j=0; j<h; j++)
  424.       {
  425.         for (i=0; i<w; i++)
  426.         {
  427.           v = d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1);
  428.           d[i] = (v+(v>=0?1:0))>>1;
  429.         }
  430.      
  431.         s+= lx2;
  432.         d+= lx2;
  433.       }
  434.     }
  435.     else
  436.     {
  437.       for (j=0; j<h; j++)
  438.       {
  439.         for (i=0; i<w; i++)
  440.         {
  441.           d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;
  442.         }
  443.  
  444.         s+= lx2;
  445.         d+= lx2;
  446.       }
  447.     }
  448.   }
  449.   else /* if (xh && yh) horizontal and vertical half-pel */
  450.   {
  451.     if (average_flag)
  452.     {
  453.       for (j=0; j<h; j++)
  454.       {
  455.         for (i=0; i<w; i++)
  456.         {
  457.           v = d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2);
  458.           d[i] = (v+(v>=0?1:0))>>1;
  459.         }
  460.      
  461.         s+= lx2;
  462.         d+= lx2;
  463.       }
  464.     }
  465.     else
  466.     {
  467.       for (j=0; j<h; j++)
  468.       {
  469.         for (i=0; i<w; i++)
  470.         {
  471.           d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
  472.         }
  473.  
  474.         s+= lx2;
  475.         d+= lx2;
  476.       }
  477.     }
  478.   }
  479. }
  480.